<!--
    store模块元素功能
    能够生成模块store，作为一个store模块的根节点
-->
<script>
/** 扩充变量说明
 * moduleStore 模块store的原型，用以生成store实例
 * storeCode 当前模块编码名称
 * parentStore 上级module的组件，不一定是组件的父级元素，是祖先中最接近的绑定store的元素，可能是模块的元素（混合storeSubModel的组件）
 * state 绑定模块的state对象，用以直接数据state
 * modulePath 模块路径，记录祖先元素的编码，用于生成方法编码以及调用和查询祖先元素的store
 * pathCode 模块路径编码，用于快速使用命名空间中的方法
 */
import Helper from 'store/helper';
import Base from './storeModuleBase';
import $ from '@/common';
function createModule(store) {
	if (this.$parentStore) {
		//若找到上级store 则 根据上级store和当前组件的encode生成模块组件的路径
		this.$modulePath = [...this.$parentStore.$modulePath, this.$storeCode];
	} else {
		//若未找到上级store 则 将跟根节点的store作为其上级store
		this.$parentStore = this.$store;
		this.$modulePath = [this.$storeCode];
	}
	//根据路径，使用store生成函数生成store实例
	//卸载同名模块，防止冲突
	//TODO 填写切换路由 卸载节点模块的逻辑
	if (this.$parentStore.moduleState) {
		if (this.$parentStore.moduleState[this.$storeCode]) {
			this.$store.unregisterModule(this.$modulePath);
		}
	}
	this.$store.registerModule(this.$modulePath, {
		...store,
		state: $.copyJson(store.state),
	});
	this.$pathCode = this.$modulePath.join('/');
	//TODO 丰富根节点store的设置，简化初始化逻辑
	var state = this.$parentStore.moduleState
		? this.$parentStore.moduleState[this.$storeCode]
		: this.$parentStore.state[this.$storeCode];
	if (this.$parentStore.moduleState && !state) {
		state = this.$parentStore.$store.state;
		for (let i = 0; i < this.$modulePath.length; i++) {
			if (state && state[this.$modulePath[i]]) {
				state = state[this.$modulePath[i]];
			} else {
				state = null;
				break;
			}
		}
	}
	if (state) {
		//this.$set(this, "moduleState", state);
		this.moduleState = state;
	} else {
		this.moduleState = state;
	}
}

var storeTypeCount = {
	module: 0,
};
//使用类目递增的方法生成唯一编码
function getStoreTypeEncode(store) {
	var type = store.name || 'module';
	if (storeTypeCount[type] === undefined) {
		storeTypeCount[type] = 0;
	} else {
		storeTypeCount[type]++;
	}
	return `${type}_${storeTypeCount[type]}`;
}

export default {
	extends: Base,
	props: {
		module: {},
	},
	created() {
		//未初始化属性添加重复设置判断，避免发生重复处理
		if (!this.$parentStore) {
			this.$parentStore = Helper.getParentStore(this);
		}
		//模块store编码
		if (!this.$storeCode) {
			this.$storeCode = this.getStoreCode();
		}
		//在组件创建步骤载入自身的模块store
		if (!this.moduleState) {
			createModule.call(this, this.$options.moduleStore);
		}
		this.$dispatch = (code, data) => {
			return this.$store.dispatch(this.$modulePath.join('/') + '/' + code, data);
		};
		this.$commit = (code, data) => {
			return this.$store.commit(this.$modulePath.join('/') + '/' + code, data);
		};
		var thisModule = this.$store._modules.root;
		for (let i in this.$modulePath) {
			thisModule = thisModule._children[this.$modulePath[i]];
		}
		if (thisModule) {
			this.$moduleContext = thisModule.context;
		} else {
			this.$moduleContext = this.$store;
		}
		this.$getters = this.$moduleContext.getters;
	},
	beforeCreate() {
		//在组件初始化前改造组件初始化选项，将store方法注入
		//storeMapping  设置组件是否自动挂载store属性
		let options = this.$options;
		Helper.storeFactory(options.moduleStore);
		if (options.storeMapping !== false) {
			Helper.bindStoreOption(this, options.moduleStore);
		}
	},
	methods: {
		//store编码生成方法，根据预先是指的data|model中的code|根据store类型 生成唯一编码
		// 可重写该方法对storeCode进行指定
		getStoreCode() {
			if (this.$storeCode) return this.$storeCode;
			if (this.module) return this.module;
			if (this.model) {
				if (this.model.code) {
					return `${this.$options.moduleStore.name || 'module'}_${this.model.code}`;
				}
			}
			//根据类型生成唯一自增编码
			return getStoreTypeEncode(this.$options.moduleStore);
		},
	},
	//元素销毁时写在store
	//不能用在Destroyed调用销毁，否则在组件重置时会与模块初始化时的unregisterModule冲突
	beforeDestroye() {
		try {
			//销毁前需检查模块是否存在，否则会报错
			if (this.$store._modules.get(this.$modulePath)) {
				this.$store.unregisterModule(this.$modulePath);
			}
		} catch (ex) {
			console.warn(ex);
		}
	},
};
</script>
